import http from '@/utils/http'

// 需要登录才能访问的页面路径

const loginPages = [
  '/src/pages/index/index',
  '/src/pages/order/list',
  '/src/pages/order/detail',
  '/src/pages/cart/index',
  '/src/pages/user/index',
  '/src/pages/address/list',
  '/src/pages/address/edit',
  '/src/pages/goods/detail',
  '/src/pages/goods/list'
]

// 登录状态管理工具

/**
 * 获取Token
 */
export function getToken() {
  try {
    return uni.getStorageSync('token') || ''
  } catch (error) {
    // console.error('获取Token失败:', error)
    return ''
  }
}

/**
 * 设置Token
 */
export function setToken(token) {
  try {
    uni.setStorageSync('token', token)
    return true
  } catch (error) {
    // console.error('设置Token失败:', error)
    return false
  }
}

/**
 * 获取用户信息
 */
export function getUserInfo() {
  try {
    return uni.getStorageSync('userInfo') || null
  } catch (error) {
    // console.error('获取用户信息失败:', error)
    return null
  }
}

/**
 * 设置用户信息
 */
export function setUserInfo(userInfo) {
  try {
    if (userInfo) {
      uni.setStorageSync('userInfo', userInfo)
      uni.setStorageSync('isLogin', true)
      // console.log('设置用户信息成功', userInfo, 'token', uni.getStorageSync('token'), 'userInfo', uni.getStorageSync('userInfo'), 'isLogin', uni.getStorageSync('isLogin'))
    }
    return true
  } catch (error) {
    // console.error('设置用户信息失败:', error)
    return false
  }
}

/**
 * 检查是否已登录
 */
export function isLoggedIn() {
  try {
    const token = getToken()
    const userInfo = getUserInfo()
    const isLogin = uni.getStorageSync('isLogin')
    return !!(token && userInfo && isLogin)
  } catch (error) {
    // console.error('检查登录状态失败:', error)
    return false
  }
}

/**
 * 退出登录
 */
export function logout() {
  try {
    uni.removeStorageSync('token')
    uni.removeStorageSync('isLogin')
    uni.removeStorageSync('userInfo')
  } catch (e) {
    // console.error('清除用户信息失败:', e)
    // 修复错误调用
    // e.error()
  }
}

/**
 * 手机号登录
 */
export async function phoneLogin(loginData) {
  try {
    // 支持两种调用方式：对象参数 或 分别传递参数
    let phone, verifyCode
    if (typeof loginData === 'object' && loginData.phone) {
      phone = String(loginData.phone) // 确保phone是字符串类型
      verifyCode = String(loginData.verification_code || loginData.code || '')
    } else {
      // 兼容旧的调用方式
      phone = String(arguments[0] || '')
      verifyCode = String(arguments[1] || '')
    }
    
    const response = await http.post('/user/phone-login', {
      phone: phone,
      zone: '86',
      code: verifyCode
    })
    // 检查响应是否成功
    if (response.code === 200 && response.data) {
      const loginData = response.data
      // 保存登录信息
      uni.setStorageSync('token', loginData.access_token)
      uni.setStorageSync('userInfo', loginData.user_info || loginData)
      uni.setStorageSync('isLogin', true)
      return true
    } else {
      throw new Error(response.message || '登录失败')
    }
  } catch (error) {
    // console.error('手机号登录失败:', error)
    throw error
  }
}

/**
 * 获取微信授权信息
 */
export function getWechatAuth() {
  return new Promise((resolve, reject) => {
    // #ifdef MP-WEIXIN
    // 小程序环境 - 先获取用户信息，再获取登录code
    wx.getUserProfile({
      desc: '用于完善用户资料',
      success: (userRes) => {
        // 获取用户信息成功后，再获取登录code
        wx.login({
          success: (loginRes) => {
            if (loginRes.code) {
              resolve({
                code: loginRes.code,
                userInfo: userRes.userInfo,
                nickname: userRes.userInfo.nickName,
                avatar: userRes.userInfo.avatarUrl,
                openid: null // 需要后端解析
              })
            } else {
              reject(new Error('获取微信登录code失败'))
            }
          },
          fail: (error) => {
            reject(new Error('微信登录失败: ' + JSON.stringify(error)))
          }
        })
      },
      fail: (error) => {
        if (error.errMsg.includes('cancel')) {
          reject(new Error('用户取消授权'))
        } else {
          reject(new Error('获取用户信息失败: ' + JSON.stringify(error)))
        }
      }
    })
    // #endif
    
    // #ifdef APP-PLUS
    // APP环境
    plus.oauth.getServices((services) => {
      let weixinOAuth = null
      for (let i in services) {
        if (services[i].id === 'weixin') {
          weixinOAuth = services[i]
          break
        }
      }
      
      if (!weixinOAuth) {
        reject(new Error('微信登录服务不可用'))
        return
      }
      
      weixinOAuth.authorize(
        (res) => {
          // 获取用户信息
          weixinOAuth.getUserInfo(
            (userRes) => {
              resolve({
                authResult: res,
                userInfo: userRes,
                nickname: userRes.nickname,
                avatar: userRes.headimgurl,
                openid: userRes.openid
              })
            },
            (error) => {
              reject(new Error('获取微信用户信息失败: ' + JSON.stringify(error)))
            }
          )
        },
        (error) => {
          if (error.code === -2) {
            reject(new Error('用户取消授权'))
          } else {
            reject(new Error('微信授权失败: ' + JSON.stringify(error)))
          }
        }
      )
    }, reject)
    // #endif
    
    // #ifdef H5
    // H5环境提示不支持
    reject(new Error('H5环境不支持微信登录，请使用手机号登录'))
    // #endif
  })
}

/**
 * 微信登录 - 完整流程
 */
export async function wechatLoginComplete() {
  try {
    // 获取微信授权信息
    const authData = await getWechatAuth()
    
    // 调用后端API进行登录
    const response = await http.post('/auth/wechat/login', {
      code: authData.code,
      userInfo: authData.userInfo,
      nickname: authData.nickname,
      avatar: authData.avatar,
      openid: authData.openid
    })
    
    // 检查响应是否成功
    if (response.code === 200 && response.data) {
      const loginData = response.data
      // 保存登录信息
      uni.setStorageSync('token', loginData.access_token || loginData.token)
      uni.setStorageSync('userInfo', loginData.user_info || loginData)
      uni.setStorageSync('isLogin', true)
      
      return {
        success: true,
        data: loginData,
        wechatInfo: authData
      }
    } else {
      throw new Error(response.message || '微信登录失败')
    }
  } catch (error) {
    console.error('微信登录失败:', error)
    throw error
  }
}

/**
 * 微信登录 - 简化版本（兼容现有代码）
 */
export async function wechatLogin(loginData) {
  try {
    // 如果传入的是code，直接调用后端API
    if (loginData.code) {
      const response = await http.post('/auth/wechat/login', {
        code: loginData.code,
        userInfo: loginData.userInfo || {},
        nickname: loginData.nickname || loginData.userInfo?.nickName,
        avatar: loginData.avatar || loginData.userInfo?.avatarUrl
      })
      
      if (response.code === 200 && response.data) {
        const userData = response.data
        uni.setStorageSync('token', userData.access_token || userData.token)
        uni.setStorageSync('userInfo', userData.user_info || userData)
        uni.setStorageSync('isLogin', true)
        return { success: true, data: userData }
      } else {
        throw new Error(response.message || '微信登录失败')
      }
    }
    
    // 如果没有code，获取完整的微信授权信息
    return await wechatLoginComplete()
  } catch (error) {
    console.error('微信登录失败:', error)
    throw error
  }
}

/**
 * 发送手机验证码
 */
export async function sendSmsCode(phoneNumber) {
  try {
    // 这里应该调用实际的API
    const res = await http.post('/user/sendSmsCode', {
      phone: String(phoneNumber), // 确保phone是字符串类型
      zone: '86'
    })
    // console.log("API响应结果:", res)
    // const response = await uni.request({
    //   url: 'http://127.0.0.1:8000/uniapp/user/send-sms-code',
    //   method: 'POST',
    //   data: { phoneNumber }
    // })
    
    // 模拟发送成功
    return {
      success: true,
      message: '验证码已发送',
      code: res.data['verification_code']
    }
  } catch (error) {
    // console.error('发送验证码失败:', error)
    throw error
  }
}

// 检查是否需要登录
export function needLogin(path) {
  // 登录页面不需要检查
  if (path === '/pages/login/index' || path === '/src/pages/login/index') {
    return false
  }
  
  // 首页不需要检查
  if (path === '/src/pages/index/index') {
    return false
  }
  
  return loginPages.some(page => path.startsWith(page))
}

// 清除用户信息
export function clearUserInfo() {
  try {
    uni.removeStorageSync('userInfo')
  } catch (e) {
    // console.error('清除用户信息失败:', e)
    e.error()
  }
}

// 跳转到登录页
export function toLogin() {
  uni.navigateTo({
    url: '/src/pages/login/index'
  })
}

// 检查登录状态并处理
export function checkLogin(path) {
  if (needLogin(path) && !isLoggedIn()) {
    // 保存当前页面路径，登录后跳转回来
    uni.setStorageSync('redirectUrl', path)
    toLogin()
    return false
  }
  return true
}

/**
 * 小程序专用微信登录测试
 */
export function testMiniProgramWechatLogin() {
  return new Promise((resolve, reject) => {
    // #ifdef MP-WEIXIN
    // console.log('🔥 开始小程序微信登录测试')
    
    // 直接获取用户信息
    wx.getUserProfile({
      desc: '登录农药商城',
      success: (userRes) => {
        // console.log('✅ 获取用户信息成功:', userRes)
        
        // 获取登录凭证
        wx.login({
          success: (loginRes) => {
            // console.log('✅ 获取登录凭证成功:', loginRes)
            
            if (loginRes.code) {
              const result = {
                code: loginRes.code,
                userInfo: userRes.userInfo,
                nickname: userRes.userInfo.nickName,
                avatar: userRes.userInfo.avatarUrl,
                rawData: userRes.rawData,
                signature: userRes.signature,
                encryptedData: userRes.encryptedData,
                iv: userRes.iv
              }
              
              // console.log('✅ 微信登录数据准备完成:', result)
              resolve(result)
            } else {
              reject(new Error('获取微信登录凭证失败'))
            }
          },
          fail: (error) => {
            // console.error('❌ 获取登录凭证失败:', error)
            reject(new Error('获取微信登录凭证失败'))
          }
        })
      },
      fail: (error) => {
        // console.error('❌ 获取用户信息失败:', error)
        if (error.errMsg && error.errMsg.includes('cancel')) {
          reject(new Error('用户取消了微信授权'))
        } else {
          reject(new Error('获取微信用户信息失败'))
        }
      }
    })
    // #endif
    
    // #ifndef MP-WEIXIN
    reject(new Error('此功能仅支持微信小程序'))
    // #endif
  })
}

// 检查并处理认证错误
export function handleAuthError(error) {
  // 处理401和403错误
  if (error.message && (error.message.includes('401') || error.message.includes('403'))) {
    // 清除登录信息
    logout()
    
    // 显示提示
    uni.showModal({
      title: '登录已过期',
      content: '您的登录已过期，请重新登录',
      showCancel: false,
      confirmText: '立即登录',
      success() {
        uni.reLaunch({
          url: '/src/pages/login/index'
        })
      }
    })
    return true
  }
  return false
}

// 在API调用前检查登录状态
export function checkAuthBeforeRequest() {
  if (!isLoggedIn()) {
    uni.showToast({
      title: '请先登录',
      icon: 'none',
      duration: 2000
    })
    setTimeout(() => {
      uni.navigateTo({
        url: '/src/pages/login/index'
      })
    }, 1500)
    return false
  }
  return true
}

// 清理存储空间，解决日志文件过大问题
export function clearStorageCache() {
  try {
    // 获取需要保留的重要数据
    const token = getToken()
    const userInfo = getUserInfo()
    const isLogin = uni.getStorageSync('isLogin')
    const cartItems = uni.getStorageSync('cartItems')
    const addressList = uni.getStorageSync('addressList')
    
    // 获取所有存储的key
    const info = uni.getStorageInfoSync()
    const keys = info.keys || []
    
    // 定义需要保留的关键数据
    const keepKeys = ['token', 'userInfo', 'isLogin', 'cartItems', 'addressList']
    
    // 只清理非关键数据
    keys.forEach(key => {
      if (!keepKeys.includes(key)) {
        try {
          uni.removeStorageSync(key)
        } catch (e) {
          // 忽略删除失败的项
        }
      }
    })
    
    // 确保重要数据还在（如果刚才的操作意外清除了）
    if (token && !uni.getStorageSync('token')) {
      setToken(token)
    }
    if (userInfo && !uni.getStorageSync('userInfo')) {
      setUserInfo(userInfo)
    }
    if (isLogin && !uni.getStorageSync('isLogin')) {
      uni.setStorageSync('isLogin', isLogin)
    }
    if (cartItems && !uni.getStorageSync('cartItems')) {
      uni.setStorageSync('cartItems', cartItems)
    }
    if (addressList && !uni.getStorageSync('addressList')) {
      uni.setStorageSync('addressList', addressList)
    }
    
    return true
  } catch (error) {
    // 如果清理失败，静默处理
    return false
  }
} 